The mantra of modern datacenters is scale out, not up. To handle ever-increasing aggregate capacities, these datacenters do not use larger-capacity components—which suffer from higher per-unit-of-capacity prices—but instead harness the aggregate capacity of large numbers of commodity components. The scale-out approach has allowed these datacenters to reach previously unthinkable levels of scale (e.g., hundreds of thousands of servers), thereby opening up exciting new computational vistas. Moreover, because the scale-out approach treats hardware as a resource pool from which individual components can be allocated to workloads on demand without manual intervention, failures can be tolerated gracefully and the operational costs per-unit-of-capacity are vanishingly small compared to those in a traditional enterprise.
Datacenter scale-out is facilitated by the use of global file systems (e.g., GFS) and programming frameworks (e.g., MapReduce) that provide a set of abstractions that shield programmers from the datacenter's underlying storage and computational hardware. More specifically, applications use servers as generic computation elements that are fed tasks by a job dispatcher or load-balancer; adding additional servers merely provides more aggregate capacity without changing the programmatic abstractions. Similarly, storage services allow multiple physical disks to be abstracted through a single block or filesystem interface, and the available storage capacity can be increased by adding more disks without disrupting existing data access or configuration. Often the data is replicated on the backend so disk failures can be handled without data loss, but this failure resilience is hidden completely behind the simple storage abstraction.
While computation and storage are scale-out success stories, networks pose a more subtle challenge to the scale-out paradigm. In terms of simple packet delivery, there have been several recent proposals that allow network forwarding to be scaled-out. The physical network is treated as a single switching fabric; load balancing is used to distribute traffic throughout the fabric, allowing newly added switches to be used effectively. This unified fabric supports a very simple forwarding abstraction to end hosts: delivery to a stable Internet Protocol (IP) address (regardless of where that host or virtual machine (VM) currently resides in the physical network). This abstraction shields applications from the underlying networking hardware, allowing for a clean scaling-out of basic packet delivery.
However, scaling out the network forwarding fabric in this fashion is not sufficient. Rather than just providing simple packet delivery, current routers and switches support a rich set of local functions such as access control lists (ACLs), isolation (via virtual local area networks (VLANs) and virtual routing and forwarding (VRF)), monitoring (e.g., remote switched port analyzer (RSPAN) and NetFlow), and bandwidth allocation (via quality of service (QoS) configuration). The overall forwarding behavior of the network depends on all these additional local functions, but they are not captured by the existing approaches that scale-out basic packet delivery.
A robust version of network scale-out is difficult because—unlike computation, storage, and simple packet delivery—there is no well-accepted abstraction for this more general form of global network behavior; instead, global network behavior is typically defined only in terms of the set of individual router/switch configurations. As a result, in networks that implement any non-trivial forwarding functionality, adding a new switch requires explicit reconfiguration of the network (not just the newly added switch) to ensure that the new network provides the same overall behavior as before. This inability to add new networking hardware without manual configuration is a barrier to the fully faithful scaling-out of network functionality. Consequently, there is a need in the art to provide a more robust scaling-out of network functionality.
Virtualization is by no means a new concept within networking. It is heavily used in practice today. For example, virtualization concepts are used to partition forwarding devices into logical subsets, and to create logical components such as L2 forwarding domains (VLANs), or logical links (e.g. multiprotocol label switching (MPLS) or generic routing encapsulation (GRE)). Further, it has been used for decades to create experimental testbeds as overlays, or partitioned physical networks.
Recently, some have suggested the use of a software layer between the control and forwarding planes of a router to facilitate migration (e.g. virtual routers on the move (VROOM) described in the proceedings of the August 2009 SIGCOMM Symposium entitled “Virtual Routers on the Move: Live Router Migration as a Network-management Primitive”). However, this approach limits to running single logical forwarding element per physical switch. Consequently, there is a need in the art to extend the logical view across multiple physical elements and support multiple logical contexts sharing the same underlying hardware. Further, there is a need in the art to focus on providing general scaling-out of control logic, not on supporting just control logic migration.
Some have also suggested building networks on top of other networks for a variety of purposes (e.g. Overlays). However, this approach is often used to introduce new functionality when the operator cannot or does not want to change (for administrative or implementation reasons) the features in the underlying hardware. For example, an overlay allows the operators to provide the overlay functionality at a small set of network nodes, and use the underlying network to provide connectivity between these overlay nodes. However, the control of the overlay itself is done with traditional mechanisms, operating on a set of physical nodes in the overlay. Consequently, there is a need in the art to use a fully logical network abstraction to express the desired functionality, and then use a software layer to map this logical abstraction to the underlying hardware. In the process of mapping the logical to the physical, the software layer can effectively create an overlay network.